{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import struct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x00\\x00\\x00\\x02'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct.pack('>i',2) # 高位字节"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./g1.png)\n",
    "![jupyter](./g2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2051, 60000, 28, 28)\n",
      "47040000\n",
      "47040000\n"
     ]
    }
   ],
   "source": [
    "## 解压数据\n",
    "import struct\n",
    "with open('./MNIST_data/train-images-idx3-ubyte','rb') as f:\n",
    "    buffer =f.read(4*4) #4个int\n",
    "    head =struct.unpack('>iiii',buffer) #读取前4个字段的数据\n",
    "    print(head)\n",
    "    length =head[1] * head[2] * head[3]\n",
    "    print(length)\n",
    "    buffer=f.read(length)\n",
    "    data =struct.unpack('>{}B'.format(length),buffer)\n",
    "    print(len(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## 显示图片\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "imgs = np.reshape(data,(head[1],head[2],head[3]))\n",
    "imgs.shape\n",
    "\n",
    "##显示5张图片\n",
    "for i in range(5):\n",
    "    plt.imshow(imgs[i],cmap='gray')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\administrator\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\utils\\deprecation.py:85: DeprecationWarning: Function fetch_mldata is deprecated; fetch_mldata was deprecated in version 0.20 and will be removed in version 0.22. Please use fetch_openml.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "c:\\users\\administrator\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\utils\\deprecation.py:85: DeprecationWarning: Function mldata_filename is deprecated; mldata_filename was deprecated in version 0.20 and will be removed in version 0.22. Please use fetch_openml.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'DESCR': 'mldata.org dataset: mnist-original',\n",
       " 'COL_NAMES': ['label', 'data'],\n",
       " 'target': array([0., 0., 0., ..., 9., 9., 9.]),\n",
       " 'data': array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## 另一种解包方式\n",
    "from sklearn.datasets import fetch_mldata\n",
    "mnist =fetch_mldata('MNIST original',data_home='./')\n",
    "mnist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* DESCR 数据集描述\n",
    "* data 包含一个数组，每个实例为一行，每个特征为一列\n",
    "* target 包含一个带有标签的数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 将数据拆分成训练集和测试集\n",
    "X,y =mnist['data'],mnist['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000, 784)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "some_digit=X[36000]\n",
    "some_digit_image=some_digit.reshape(28,28)\n",
    "\n",
    "##显示图片\n",
    "plt.imshow(some_digit_image,cmap=matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[36000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立测试集合训练集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8), array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8), array([0., 0., 0., ..., 9., 9., 9.]), array([0., 0., 0., ..., 9., 9., 9.]))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train,X_test,y_train,y_test =X[:60000],X[60000:],y[:60000],y[60000:]\n",
    "X_train,X_test,y_train,y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([22463, 16090, 26964, ..., 41691, 29037, 27904])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#将数据集合交叉洗牌，交叉验证时，每个子集合数据分布均匀，有些机器学习算法对训练实例的顺序敏感\n",
    "import numpy as np\n",
    "shuffle_index =np.random.permutation(60000)\n",
    "shuffle_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8),\n",
       " array([3., 2., 4., ..., 6., 4., 4.]))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train,y_train=X_train[shuffle_index],y_train[shuffle_index]\n",
    "X_train,y_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练一个二元分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 识别数字5，二元分类5或者非5\n",
    "\n",
    "y_train_5=(y_train==5)\n",
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [ True, False, False, ..., False, False, False],\n",
       "       ...,\n",
       "       [False, False, False, ...,  True, False,  True],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_5.reshape(20,-1) #重新塑型\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_5=(y_test==5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#SGD 梯度下降 分类器，适合非常大的数据集，独立处理训练集数据，一次一个，适合在线学习\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "\n",
    "sgd_clf=SGDClassifier(random_state =42)\n",
    "sgd_clf.fit(X_train,y_train_5)\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 性能考核"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用交叉验证测量精度\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.9648, 0.9577, 0.9628])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器比评估回归器要困难得多\n",
    "# 3个折叠，正确率达到95%以上\n",
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(sgd_clf,X_train,y_train_5,cv=3,scoring='accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把每张图都分类成 非5（估算器）\n",
    "from sklearn.base import BaseEstimator\n",
    "class Never5Classfier(BaseEstimator):\n",
    "    def fit(self,X,y=None):\n",
    "        pass\n",
    "    def predict(self,X):\n",
    "        return np.zeros((len(X),1),dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False],\n",
       "       [False],\n",
       "       [False],\n",
       "       ...,\n",
       "       [False],\n",
       "       [False],\n",
       "       [False]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((len(X),1),dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.90815, 0.9102 , 0.9106 ])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "never_5_clf=Never5Classfier()\n",
    "cross_val_score(never_5_clf,X_train,y_train_5,cv=3,scoring='accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 准确率超过90% ，因为5的图像大约只有10%，你猜一张图不是5， 90%的时间你都是正确的\n",
    "* 这说明准确率无法成为分类器的首要性能指标，特别是当你处理偏科数据集， 某些类比其他类更为频繁"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器性能的更好方法是混淆矩阵\n",
    "# A类别实例被分为B类别次数\n",
    "# 想要知道分类器将数字3和数字5混淆多少次，通过混淆矩阵的5行3列\n",
    "from sklearn.model_selection import cross_val_predict\n",
    "\n",
    "y_train_pred=cross_val_predict(sgd_clf,X_train,y_train_5,cv=3)\n",
    "y_train_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 与cross_val_score 对比"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 同样执行交叉验证\n",
    "* 返回的不是评估分数，是每个折叠的预测\n",
    "* 每一个实例在模型预测时使用的数据，在训练期间从未出现过"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54163,   416],\n",
       "       [ 1878,  3543]], dtype=int64)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "confusion_matrix(y_train_5,y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 行表示实际类别，列表示预测类别\n",
    "# 第一行 第一列 53272 被正确的分为 非5 ，真负类\n",
    "# 第一行 第二列 1307 被错误的分类成 5 ，假正类\n",
    "# 第二行 第一列 1077 张被错误的分为 非5， 假负类\n",
    "# 第二行 第二列 4344 张被正确的分在了5 ，真正类\n",
    "# 这种衡量方式太复杂，我们可以用更简单的指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54579,     0],\n",
       "       [    0,  5421]], dtype=int64)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_perfect_predictions =y_train_5\n",
    "confusion_matrix(y_train_5,y_train_perfect_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 正类预测的准确率 被称为分类器的精度\n",
    "\n",
    "\n",
    "$\n",
    "\\text{精度} = \\cfrac{TP}{TP + FP}\n",
    "$\n",
    "\n",
    "TP是真正类的数量，FP是假正类的数量\n",
    "\n",
    "\n",
    "\n",
    "$\n",
    "\\text{召回率TPR} = \\cfrac{TP}{TP + FN}\n",
    "$\n",
    "* 检测正类实例的比例\n",
    "FN是假负类的数量\n",
    "![jupyter](./zhaohui.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度和召回率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_score,recall_score  #精度，召回率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8949229603435211"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train_5,y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6535694521306032"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5,y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 说明 检测一张图的时候，只有59%的概率是准确的，而且只有85%的数字5 被它检测出来\n",
    "# 精度和召回率合成单一指标，成为 F1 分数，谐波平均值\n",
    "# 平均值平等对待所有的值，谐波平均值会给予较低值更高的权重，只有召回率和精度都很高时，才能获得较高的F1分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "F_1 = \\cfrac{2}{\\cfrac{1}{\\text{precision}} + \\cfrac{1}{\\text{recall}}} = 2 \\times \\cfrac{\\text{precision}\\, \\times \\, \\text{recall}}{\\text{precision}\\, + \\, \\text{recall}} = \\cfrac{TP}{TP + \\cfrac{FN + FP}{2}}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7554371002132197"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# F1 谐波平均值\n",
    "from sklearn.metrics import f1_score\n",
    "f1_score(y_train_5,y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# F1分数对那些具有相近精度和召回率 分类器更有利，这不一定符合你的期望\n",
    "# 有时候你更关心精度，有时你能关心召回率\n",
    "# 训练一个分类器检测儿童可以放心观看的视频，你可能要求拦截了很多好的视频，低召回率，保留下来的都是安全的视频，高精度\n",
    "# 不能同时增加精度并减少召回率，反之亦然"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度、召回率权衡"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./quanheng.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* SGDClassifier对每个实例基于决策函数计算一个分值，大于阀值为正类，否则为负类\n",
    "* 中间阀值右侧找到4个真正类 真5 ， 一个假正类 6， 精度为 4/5 80%\n",
    "* 在所有的6个 真正的5 中，分类器找到了4个，召回率为 4/6 67%\n",
    "* 提高阀值，向右移动，精度提高，召回降低\n",
    "* 反之阀值降低，召回提高，精度降低\n",
    "* SKlearn不可以直接设置阀值，可以访问决策分数，\n",
    "* SGDClassifier 默认阀值为0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([753.94243928])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回决策值\n",
    "y_scores = sgd_clf.decision_function([some_digit])\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold =0 \n",
    "y_some_digit_pred=(y_scores > threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提高阈值可以降低召回率，提高阈值到200000，就错了这个图\n",
    "threshold=200000\n",
    "y_some_digit_pred=(y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#如何决定使用什么值\n",
    "#返回决策值，而不是预测结果\n",
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,\n",
    "                             method=\"decision_function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000,)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 有了y_scores，可以计算所有可能的阀值的精度和召回率\n",
    "y_scores.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)\n",
    "\n",
    "# 使用matplotlib 绘制精度和召回相对于阀值的函数图\n",
    "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n",
    "    plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precision\", linewidth=2)\n",
    "    plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n",
    "    plt.xlabel(\"Threshold\", fontsize=16)\n",
    "    plt.legend(loc=\"upper left\", fontsize=16)\n",
    "    plt.ylim([0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n",
    "plt.xlim([-700000, 700000])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#绘制PR\n",
    "plt.rcParams['font.sans-serif'] =['SimHei']\n",
    "def plot_percision_vs_recall(precisions,recalls):\n",
    "    plt.plot(recalls,precisions,\"b-\",linewidth=2)\n",
    "    plt.xlabel(\"召回\",fontsize=16)\n",
    "    plt.ylabel(\"精度\",fontsize=16)\n",
    "    plt.axis([0,1,0,1])\n",
    "\n",
    "plt.figure(figsize=(8,6))\n",
    "plot_percision_vs_recall(precisions,recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通过选择阈值来实现最佳的精度、召回率权衡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9582504970178927"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 目标设定为%90的精度，阈值大概在5000左右。设置了阈值为5000\n",
    "y_train_pred_90 =(y_scores > 5000)\n",
    "\n",
    "precision_score(y_train_5,y_train_pred_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.35565393838775133"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 召回率\n",
    "recall_score(y_train_5,y_train_pred_90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 获得了一个90%精度的分类器，但如果召回太低，精度再高，也不怎么有用\n",
    "* 如果工作中，需要99%的精度，你应该回应，召回率是多少？\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 本质是 真正类率 tpr和假正类率fpr(错误的分为正类的负类实例比例)\n",
    "# 与召回/精度曲线非常相似\n",
    "\n",
    "from sklearn.metrics import roc_curve\n",
    "\n",
    "fpr,tpr,thresholds = roc_curve(y_train_5,y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.        , 0.        , 0.        , ..., 0.99300097, 0.99300097,\n",
       "        1.        ]),\n",
       " array([0.00000000e+00, 1.84467810e-04, 1.29127467e-03, ...,\n",
       "        9.99815532e-01, 1.00000000e+00, 1.00000000e+00]),\n",
       " array([  30655.99725328,   30654.99725328,   28160.70361314, ...,\n",
       "         -71628.01966919,  -71761.17106993, -160337.49644646]))"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fpr,tpr,thresholds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制ROC曲线\n",
    "plt.rcParams['font.sans-serif'] =['SimHei']\n",
    "def plot_roc_curve(fpr,tpr,label =None):\n",
    "    plt.plot(fpr,tpr,linewidth=2,label=label)\n",
    "    plt.plot([0,1],[0,1],'k--')\n",
    "    plt.axis([0,1,0,1])\n",
    "    plt.xlabel(\"假正类率\",fontsize=16)\n",
    "    plt.ylabel(\"假正类率\",fontsize=16)\n",
    "    \n",
    "\n",
    "plt.figure(figsize=(8,6))\n",
    "plot_roc_curve(fpr,tpr)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9596004003869786"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算曲线下面AUC，虚线是随机分类0.5 到1\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "roc_auc_score(y_train_5,y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 召回率TPR越高，分类器的假正类FPR就越多\n",
    "* 虚线表示纯随机分类器的ROC曲线，好的分类器应该远离这条线，向左上角\n",
    "* 是使用精度/召回率PR曲线，还是使用ROC,关键在于正类非常少或者更关注假正类而不是假负类，选择PR,反之ROC\n",
    "* 例如：前面例子ROC曲线很不错是因为跟负类非5相比，正类数据5数量真的很少"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练随机森林分类器，比较SGD分类器的ROC曲线和ROC AUC分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 获取训练集中每个实例的分数\n",
    "* RandomForestClassifier 没有decision_function(),但是拥有 dict_proda()方法，sklearn中分\n",
    "  类器都有这两个中的一个\n",
    "* dict_proda返回一个矩阵，每行一个实例，每列代表一个类别的概率，比如这个图片70%是5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 随机森林\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "forest_clf =RandomForestClassifier(n_estimators =10,random_state =42)\n",
    "y_probas_forest=cross_val_predict(forest_clf,X_train,y_train_5,cv=3,method=\"predict_proba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 0. ],\n",
       "       [0.7, 0.3],\n",
       "       [0.8, 0.2],\n",
       "       ...,\n",
       "       [1. , 0. ],\n",
       "       [1. , 0. ],\n",
       "       [1. , 0. ]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_probas_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制ROC曲线，需要决策值不是概率，直接使用正类的概率作为决策值\n",
    "y_scores_forest =y_probas_forest[:,1]\n",
    "fpr_forest,tpr_forest,thresholds_forest=roc_curve(y_train_5,y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.3, 0.2, ..., 0. , 0. , 0. ])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,6))\n",
    "plt.plot(fpr,tpr,\"b:\",linewidth=2,label=\"SGD\")\n",
    "plot_roc_curve(fpr_forest,tpr_forest,\"Random Forest\")\n",
    "plt.legend(loc=\"lower right\",fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9928052281420067"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 可以看出Rand 比SGD好很多，ROC AUC的分数也高很多\n",
    "roc_auc_score(y_train_5,y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9872834904626179"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 在看一下精度和召回率\n",
    "\n",
    "y_train_pred_forest=cross_val_predict(forest_clf,X_train,y_train_5,cv=3)\n",
    "\n",
    "precision_score(y_train_5,y_train_pred_forest) #精度\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8306585500830105"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5,y_train_pred_forest) #召回率"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 总结\n",
    "* 选择合适的指标利用交叉验证来对分类器进行评估\n",
    "* 选择满足需求的精度/召回率权衡\n",
    "* 使用ROC曲线和ROC AUC分数比较多个模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多类别分类器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 尝试5之外的检测\n",
    "* 多类别分类器 区分两个以上的类别\n",
    "* 随机森林和朴素 贝叶斯可以直接处理多个类别\n",
    "* 支持向量机svm和线性分类器只可以处理二元分类器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 解决方案"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 将数字图片分类0到9，训练10个二元分类器，每个数字一个，检测一张图片时，获取每个分类器的决策分数，哪个最高属于哪个，称为一对多OvA\n",
    "2. 为每一对数字训练一个二元分类器，区分0，1 区分0，2 区分1，2 称为一对一OvO策略，存在N个类别，需要N*（N-1）/2个分类器，最后看哪个类别获胜最多\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 优缺点\n",
    "* OvO 只需要用到部分训练集对其必须区分两个类别进行训练\n",
    "* 对于较小训练集合OvO比较有优势， 大训练集合 OvA 速度快，所以OvA更常用，比如svm 在数据规模扩大时表现糟糕\n",
    "* sklearn 检查到使用二元分类算法进行多类别分类任务，会自动运行OvA，SVM分类器除外"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## OvA\n",
    "sgd_clf.fit(X_train,y_train)\n",
    "sgd_clf.predict([some_digit])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-25003.6195558 , -29880.23345752,  -6457.59717498,\n",
       "         -2807.45089668, -19326.48006849,   1835.2646908 ,\n",
       "        -36552.53616221, -15823.89707521, -13619.18542236,\n",
       "        -18469.34362952]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 内部实际上训练了10个二元分类器，获得图片的决策分数，然后选择了分数最高的类别\n",
    "# 返回10个分数，每个类别1个\n",
    "some_digit_scores=sgd_clf.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(some_digit_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 目标类别列表会存储在classes_这个属性中，按值大小排列\n",
    "sgd_clf.classes_[np.argmax(some_digit_scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用OvO策略，一对一或者一对多\n",
    "from sklearn.multiclass import OneVsOneClassifier\n",
    "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5,tol=-np.infty,random_state=42))\n",
    "ovo_clf.fit(X_train,y_train)\n",
    "ovo_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ovo_clf.estimators_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用随机森林\n",
    "forest_clf.fit(X_train,y_train)\n",
    "forest_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.1, 0. , 0. , 0.1, 0. , 0.8, 0. , 0. , 0. , 0. ]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机森林直接将实例分为多个类别，调用predict_proba()可以获得分类器将每个实例分类为每个类别的概率列表\n",
    "forest_clf.predict_proba([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 评估分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.86537692, 0.87759388, 0.86367955])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用交叉验证评估SGD的准确率\n",
    "cross_val_score(sgd_clf,X_train,y_train,cv=3,scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\administrator\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:561: ConvergenceWarning: Maximum number of iteration reached before convergence. Consider increasing max_iter to improve the fit.\n",
      "  ConvergenceWarning)\n",
      "c:\\users\\administrator\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:561: ConvergenceWarning: Maximum number of iteration reached before convergence. Consider increasing max_iter to improve the fit.\n",
      "  ConvergenceWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.89732054, 0.90249512, 0.90443567])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将输入进行简单缩放 ，可以得到准确率 90 %以上\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()\n",
    "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n",
    "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 错误分析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 项目流程\n",
    "1. 探索数据准备的选项\n",
    "2. 尝试多个模型\n",
    "3. 选择最佳模型并用GridSearchCV对参数进行微调\n",
    "4. 尽可能自动化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 确定了一个相对合适的模型，进一步优化，分析其错误类型\n",
    "* 查看混淆矩阵\n",
    "* 使用cross_val_predict()进行预测\n",
    "* 调用confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\administrator\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:561: ConvergenceWarning: Maximum number of iteration reached before convergence. Consider increasing max_iter to improve the fit.\n",
      "  ConvergenceWarning)\n",
      "c:\\users\\administrator\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:561: ConvergenceWarning: Maximum number of iteration reached before convergence. Consider increasing max_iter to improve the fit.\n",
      "  ConvergenceWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5588,    0,   16,    7,    8,   48,   35,    5,  215,    1],\n",
       "       [   1, 6414,   45,   25,    2,   42,    6,    9,  189,    9],\n",
       "       [  27,   27, 5260,   85,   72,   24,   73,   33,  347,   10],\n",
       "       [  24,   24,  113, 5232,    1,  208,   29,   46,  390,   64],\n",
       "       [  11,   12,   43,   11, 5249,   10,   42,   19,  288,  157],\n",
       "       [  25,   16,   29,  151,   54, 4494,   80,   16,  488,   68],\n",
       "       [  29,   19,   48,    2,   41,   95, 5557,    7,  119,    1],\n",
       "       [  24,   14,   50,   23,   48,   11,    4, 5717,  169,  205],\n",
       "       [  17,   62,   42,  109,    3,  118,   29,    9, 5420,   42],\n",
       "       [  22,   24,   32,   59,  117,   43,    1,  179,  318, 5154]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred=cross_val_predict(sgd_clf,X_train_scaled,y_train,cv=3)\n",
    "conf_mx=confusion_matrix(y_train,y_train_pred)\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib的matshow函数来查看混淆矩阵的 图像表示\n",
    "plt.matshow(conf_mx,cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把焦点放在错误上，为取得错误率，而不是错误绝对值，需要将混淆矩阵中每个值除以相应类别中的图片数量\n",
    "row_sums =conf_mx.sum(axis=1,keepdims=True)\n",
    "norm_conf_mx =conf_mx / row_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "norm_conf_mx\n",
    "\n",
    "#用0填充对角线，只保留错误，重新绘制\n",
    "np.fill_diagonal(norm_conf_mx,0)\n",
    "plt.matshow(norm_conf_mx,cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 每行代表实际类别，每列代表预测类别\n",
    "# 8，9列比较亮，说明许多图片被错误的分类为数字8，9\n",
    "# 类别8，9行也偏亮，说明数字8和9经常会跟其他数字混淆\n",
    "# 有些很暗，比如行1，大多数数字1都被正确的分类，一些和8混淆\n",
    "# 5和3是错误最多的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 结论\n",
    "* 改进数字8和9的分类\n",
    "* 修正数字3和5的混淆"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何优化分类器\n",
    "* 尝试多收集这些数字的训练集\n",
    "* 开发一些新特征来改进分类器\n",
    "* 优化分类器算法\n",
    "* 使用pillow或opencv对图片预处理，让显示模型更突出\n",
    "* 分析单个错误"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_digits(instances,images_per_row =10,**options):\n",
    "    size=28\n",
    "    images_per_row =min(len(instances),images_per_row)\n",
    "    images=[instance.reshape(size,size) for instance in instances]\n",
    "    n_rows=(len(instances)-1) // images_per_row+1\n",
    "    row_images=[]\n",
    "    n_empty=n_rows * images_per_row -len(instances)\n",
    "    images.append(np.zeros((size,size * n_empty)))\n",
    "    for row in range(n_rows):\n",
    "        rimages =images[row * images_per_row:(row +1 ) * images_per_row]\n",
    "        row_images.append(np.concatenate(rimages,axis=1))\n",
    "    image=np.concatenate(row_images,axis=0)\n",
    "    plt.imshow(image,cmap=matplotlib.cm.binary,**options)\n",
    "    plt.axis(\"off\")\n",
    "    \n",
    "#查看数字3和数字5的例子\n",
    "cl_a,cl_b=3,5\n",
    "\n",
    "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n",
    "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]\n",
    "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
    "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n",
    "\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.subplot(221)\n",
    "plot_digits(X_aa[:25],images_per_row =5)\n",
    "plt.subplot(222)\n",
    "plot_digits(X_ab[:25],images_per_row =5)\n",
    "plt.subplot(223)\n",
    "plot_digits(X_ba[:25],images_per_row =5)\n",
    "plt.subplot(224)\n",
    "plot_digits(X_bb[:25],images_per_row =5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 左侧两个是被分类为3的图片\n",
    "# 右侧两个是被分类为5的图片\n",
    "# 大多数错误分类的图片看起来还是非常明显的错误\n",
    "# 原因：SGD是一个线性模型，它所做就是为每个像素分配一个各个类别的权重，当它看到新的图像，将加权后的像素强度汇总，从而得到一个分数进行分类\n",
    "# 数字3和5在一部分像素位上有区别，所以分类器很容易将其弄混\n",
    "# 通过上面图像，如果书写3 的连接点左移，分类器可能将其分类为数字5，这个分类器对图像位移和旋转敏感\n",
    "# 减少混淆的方法之一，就是对图像进行预处理，确保位于中心位置并且没有旋转"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多标签分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 为每个实例产生多个类别 ，例如 照片识别多个人脸\n",
    "# 分类器经过训练可以识别小红，小白，小军，一张照片 里有 小红，小白\n",
    "# 经过分类器，应该输出[1,1,0]， 是小红，是小白，不是小军\n",
    "# 输出多个二元标签的分类系统称为多标签分类系统"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "                     metric_params=None, n_jobs=None, n_neighbors=5, p=2,\n",
       "                     weights='uniform')"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_large=(y_train >=7)\n",
    "y_train_odd =(y_train % 2 ==1)\n",
    "y_multilabel =np.c_[y_train_large,y_train_odd]\n",
    "\n",
    "knn_clf=KNeighborsClassifier()\n",
    "\n",
    "knn_clf.fit(X_train,y_multilabel)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#knn支持多标签分类，不是所有的分类器都支持\n",
    "knn_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 评估多标签分类器方法很多，方法之一就是测量每个标签的F1分数，或者其他二元分类器指标，然后简单平均\n",
    "# y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3)\n",
    "# f1_score(y_multilabel, y_train_knn_pred, average=\"macro\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多输出分类\n",
    "### 例子：构建一个系统去除图片中的噪声，输入一张有噪声的图片，它将输入一张干净的数字图片，分类器输出是多个标签，一个像素一个标签，每个标签多个值0到255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 增加噪声，目标将图片还原为原始图片，创建训练集和测试集\n",
    "noise=np.random.randint(0,100,(len(X_train),784))\n",
    "X_train_mod =X_train +noise\n",
    "\n",
    "noise=np.random.randint(0,100,(len(X_test),784))\n",
    "X_test_mod =X_test +noise\n",
    "\n",
    "\n",
    "y_train_mod = X_train\n",
    "y_test_mod = X_test\n",
    "\n",
    "some_index=5500\n",
    "plt.subplot(121);plt.imshow(X_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.subplot(122);plt.imshow(y_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#清除噪声的\n",
    "knn_clf.fit(X_train_mod, y_train_mod)\n",
    "clean_digit = knn_clf.predict([X_test_mod[some_index]])\n",
    "\n",
    "#绘制清除噪声后的图片\n",
    "plt.imshow(clean_digit.reshape(28,28),cmap=matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
